/*
 * This file is part of the OregonCore Project. See AUTHORS file for Copyright information
 *
 * This program is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License as published by the
 * Free Software Foundation; either version 2 of the License, or (at your
 * option) any later version.
 *
 * This program is distributed in the hope that it will be useful, but WITHOUT
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
 * more details.
 *
 * You should have received a copy of the GNU General Public License along
 * with this program. If not, see <http://www.gnu.org/licenses/>.
 */

#ifndef THREADING_H
#define THREADING_H

#include <set>
#include <ace/Thread.h>
#include <ace/TSS_T.h>
#include "ace/Atomic_Op.h"
#include <assert.h>

namespace ACE_Based
{

class Runnable
{
    public:
        virtual ~Runnable() {}
        virtual void run() = 0;

        void incReference()
        {
            ++m_refs;
        }
        void decReference()
        {
            if (!--m_refs)
                delete this;
        }
    private:
        ACE_Atomic_Op<ACE_Thread_Mutex, long> m_refs;
};

enum Priority
{
    Idle,
    Lowest,
    Low,
    Normal,
    High,
    Highest,
    Realtime,
};

#define MAXPRIORITYNUM (Realtime + 1)

class ThreadPriority
{
    public:
        ThreadPriority();
        int getPriority(Priority p) const;

    private:
        int m_priority[MAXPRIORITYNUM];
};

class Thread
{
    public:
        Thread();
        explicit Thread(Runnable* instance);
        ~Thread();

        bool start();
        bool wait();

        void suspend();
        bool kill(int signal);
        void resume();

        void setPriority(Priority type);

        static void Sleep(unsigned long msecs);
        static ACE_thread_t currentId();
        static ACE_hthread_t currentHandle();
        static Thread* current();

        ACE_thread_t getId() const { return m_iThreadId; }

    private:
        Thread(const Thread&);
        Thread& operator=(const Thread&);

        static ACE_THR_FUNC_RETURN ThreadTask(void* param);

        ACE_thread_t m_iThreadId;
        ACE_hthread_t m_hThreadHandle;
        Runnable* m_task;

        typedef ACE_TSS<Thread> ThreadStorage;
        //global object - container for Thread class representation of every thread
        static ThreadStorage m_ThreadStorage;
        //use this object to determine current OS thread priority values mapped to enum Priority{}
        static ThreadPriority m_TpEnum;
};

}
#endif

